package guia1;

public class ConjuntoNatural {

    NumeroNatural[] conjunto;
    int posicionActual;
    public ConjuntoNatural()
    {
        conjunto = new NumeroNatural[100];
        posicionActual = -1;
    }
    /*
        Este método retorna true en caso que el argumento se encuentre
        almacenado en el conjunto. Caso contrario retorna false.
    */
    public boolean pertenece(NumeroNatural unNumero)
    {
        boolean corte = false;
        for(int i = 0; (i < posicionActual) && !corte ; i ++)
             corte = unNumero.equals(conjunto[i]);
        return corte;
    }
    /*
         Método que agrega el argumento unNumero al conjunto. La
         inserción se puede llevar a cabo siempre que no pertenezca dicho
         número en el conjunto.
    */
    public void agregar(NumeroNatural unNumero)
    {
		if(!pertenece(unNumero))
          if((posicionActual + 1) < 100)
           {
               posicionActual += 1;
               conjunto[posicionActual] = unNumero;
           }
    }
    /*
      Método que retorna true en caso que el conjunto no tenga elementos.
    */
    public boolean vacio()
    {
        return (posicionActual == -1);

    }
     /*
           Método que retorna el mayor numero del conjunto. En caso que él
           conjunto este vacío el método retorna null.
     */
     public NumeroNatural mayor()
     {
		if(!vacio())
         {
               NumeroNatural mayor = conjunto[0];
               for(int i = 1; (i < posicionActual); i ++)
                    if(mayor.compara(conjunto[i]) == 1)
                    mayor = conjunto[i];
               return mayor;
         }
         else
            return null;
     }
   /*
        Método que retorna la cantidad de elementos que tiene el conjunto.
   */
   public int tamanio()
   {
       return posicionActual + 1;
   }
   /*
        Retorna el elemento que se encuentra en la posición determinado por
        el argumento indice. En caso que él indice no se valido el método
        retorna null.
   */
   public NumeroNatural elementoEnPosicion(int indice)
   {
       if((indice <= posicionActual) && (indice > -1))
    	   return conjunto[indice];
       else
    	   return null;
   }
   
   /*
	   Este método elimina el número argumento del conjunto y retorna true. El método también
	   deberá hacer la reordenación de los elementos del conjunto (arreglo) para que el mismo
	   quede consistente.
   */
   
   public boolean eliminarNumero(NumeroNatural unNumero) 
   {
	   boolean exito = false;
	   for(int i=0; (i<posicionActual); i++) 
	   {
		   if (!exito) 
		   {
			   if(conjunto[i].equals(unNumero))
			   {
				   exito=true;
			   }
		   }
		   else
		   {
			   conjunto[i-1]=conjunto[i];
		   }
	   }
	   if (exito) {
		   posicionActual--;
	   }
	   return exito;
		   
   }

}
